Linux Cubed Series 2: Applications

home *** CD-ROM | disk | FTP | other *** search

/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.006 / xemacs-1 / lib / xemacs-19.13 / info / lispref.info-21 < prev next >

Wrap

GNU Info File | 1995-09-01 | 46.3 KB | 1,086 lines

This is Info file ../../info/lispref.info, produced by Makeinfo-1.63 from the input file lispref.texi. Edition History: GNU Emacs Lisp Reference Manual Second Edition (v2.01), May 1993 GNU Emacs Lisp Reference Manual Further Revised (v2.02), August 1993 Lucid Emacs Lisp Reference Manual (for 19.10) First Edition, March 1994 XEmacs Lisp Programmer's Manual (for 19.12) Second Edition, April 1995 GNU Emacs Lisp Reference Manual v2.4, June 1995 XEmacs Lisp Programmer's Manual (for 19.13) Third Edition, July 1995 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. Copyright (C) 1994, 1995 Sun Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation. Copyright (C) 1995 Ben Wing. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled "GNU General Public License" is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the section entitled "GNU General Public License" may be included in a translation approved by the Free Software Foundation instead of in the original English. File: lispref.info, Node: Magic File Names, Next: Partial Files, Prev: Create/Delete Dirs, Up: Files Making Certain File Names "Magic" ================================= You can implement special handling for certain file names. This is called making those names "magic". You must supply a regular expression to define the class of names (all those that match the regular expression), plus a handler that implements all the primitive XEmacs file operations for file names that do match. The variable `file-name-handler-alist' holds a list of handlers, together with regular expressions that determine when to apply each handler. Each element has this form: (REGEXP . HANDLER) All the XEmacs primitives for file access and file name transformation check the given file name against `file-name-handler-alist'. If the file name matches REGEXP, the primitives handle that file by calling HANDLER. The first argument given to HANDLER is the name of the primitive; the remaining arguments are the arguments that were passed to that operation. (The first of these arguments is typically the file name itself.) For example, if you do this: (file-exists-p FILENAME) and FILENAME has handler HANDLER, then HANDLER is called like this: (funcall HANDLER 'file-exists-p FILENAME) Here are the operations that a magic file name handler gets to handle: `add-name-to-file', `copy-file', `delete-directory', `delete-file', `diff-latest-backup-file', `directory-file-name', `directory-files', `dired-compress-file', `dired-uncache', `expand-file-name', `file-accessible-directory-p', `file-attributes', `file-directory-p', `file-executable-p', `file-exists-p', `file-local-copy', `file-modes', `file-name-all-completions', `file-name-as-directory', `file-name-completion', `file-name-directory', `file-name-nondirectory', `file-name-sans-versions', `file-newer-than-file-p', `file-readable-p', `file-regular-p', `file-symlink-p', `file-truename', `file-writable-p', `get-file-buffer', `insert-directory', `insert-file-contents', `load', `make-directory', `make-symbolic-link', `rename-file', `set-file-modes', `set-visited-file-modtime', `unhandled-file-name-directory', `verify-visited-file-modtime', `write-region'. Handlers for `insert-file-contents' typically need to clear the buffer's modified flag, with `(set-buffer-modified-p nil)', if the VISIT argument is non-`nil'. This also has the effect of unlocking the buffer if it is locked. The handler function must handle all of the above operations, and possibly others to be added in the future. It need not implement all these operations itself--when it has nothing special to do for a certain operation, it can reinvoke the primitive, to handle the operation "in the usual way". It should always reinvoke the primitive for an operation it does not recognize. Here's one way to do this: (defun my-file-handler (operation &rest args) ;; First check for the specific operations ;; that we have special handling for. (cond ((eq operation 'insert-file-contents) ...) ((eq operation 'write-region) ...) ... ;; Handle any operation we don't know about. (t (let ((inhibit-file-name-handlers (cons 'my-file-handler (and (eq inhibit-file-name-operation operation) inhibit-file-name-handlers))) (inhibit-file-name-operation operation)) (apply operation args))))) When a handler function decides to call the ordinary Emacs primitive for the operation at hand, it needs to prevent the primitive from calling the same handler once again, thus leading to an infinite recursion. The example above shows how to do this, with the variables `inhibit-file-name-handlers' and `inhibit-file-name-operation'. Be careful to use them exactly as shown above; the details are crucial for proper behavior in the case of multiple handlers, and for operations that have two file names that may each have handlers. - Variable: inhibit-file-name-handlers This variable holds a list of handlers whose use is presently inhibited for a certain operation. - Variable: inhibit-file-name-operation The operation for which certain handlers are presently inhibited. - Function: find-file-name-handler FILE OPERATION This function returns the handler function for file name FILE, or `nil' if there is none. The argument OPERATION should be the operation to be performed on the file--the value you will pass to the handler as its first argument when you call it. The operation is needed for comparison with `inhibit-file-name-operation'. - Function: file-local-copy FILENAME This function copies file FILENAME to an ordinary non-magic file, if it isn't one already. If FILENAME specifies a "magic" file name, which programs outside Emacs cannot directly read or write, this copies the contents to an ordinary file and returns that file's name. If FILENAME is an ordinary file name, not magic, then this function does nothing and returns `nil'. - Function: unhandled-file-name-directory FILENAME This function returns the name of a directory that is not magic. It uses the directory part of FILENAME if that is not magic. Otherwise, it asks the handler what to do. This is useful for running a subprocess; every subprocess must have a non-magic directory to serve as its current directory, and this function is a good way to come up with one. File: lispref.info, Node: Partial Files, Next: Format Conversion, Prev: Magic File Names, Up: Files Partial Files ============= * Menu: * Intro to Partial Files:: * Creating a Partial File:: * Detached Partial Files:: File: lispref.info, Node: Intro to Partial Files, Next: Creating a Partial File, Up: Partial Files Intro to Partial Files ---------------------- A "partial file" is a section of a buffer (called the "master buffer") that is placed in its own buffer and treated as its own file. Changes made to the partial file are not reflected in the master buffer until the partial file is "saved" using the standard buffer save commands. Partial files can be "reverted" (from the master buffer) just like normal files. When a file part is active on a master buffer, that section of the master buffer is marked as read-only. Two file parts on the same master buffer are not allowed to overlap. Partial file buffers are indicated by the words `File Part' in the modeline. The master buffer knows about all the partial files that are active on it, and thus killing or reverting the master buffer will be handled properly. When the master buffer is saved, if there are any unsaved partial files active on it then the user will be given the opportunity to first save these files. When a partial file buffer is first modified, the master buffer is automatically marked as modified so that saving the master buffer will work correctly. File: lispref.info, Node: Creating a Partial File, Next: Detached Partial Files, Prev: Intro to Partial Files, Up: Partial Files Creating a Partial File ----------------------- - Function: make-file-part &optional START END NAME BUFFER Make a file part on buffer BUFFER out of the region. Call it NAME. This command creates a new buffer containing the contents of the region and marks the buffer as referring to the specified buffer, called the "master buffer". When the file-part buffer is saved, its changes are integrated back into the master buffer. When the master buffer is deleted, all file parts are deleted with it. When called from a function, expects four arguments, START, END, NAME, and BUFFER, all of which are optional and default to the beginning of BUFFER, the end of BUFFER, a name generated from BUFFER name, and the current buffer, respectively. File: lispref.info, Node: Detached Partial Files, Prev: Creating a Partial File, Up: Partial Files Detached Partial Files ---------------------- Every partial file has an extent in the master buffer associated with it (called the "master extent"), marking where in the master buffer the partial file begins and ends. If the text in master buffer that is contained by the extent is deleted, then the extent becomes "detached", meaning that it no longer refers to a specific region of the master buffer. This can happen either when the text is deleted directly or when the master buffer is reverted. Neither of these should happen in normal usage because the master buffer should generally not be edited directly. Before doing any operation that references a partial file's master extent, XEmacs checks to make sure that the extent is not detached. If this is the case, XEmacs warns the user of this and the master extent is deleted out of the master buffer, disconnecting the file part. The file part's filename is cleared and thus must be explicitly specified if the detached file part is to be saved. File: lispref.info, Node: Format Conversion, Next: Files and MS-DOS, Prev: Partial Files, Up: Files File Format Conversion ====================== The variable `format-alist' defines a list of "file formats", which describe textual representations used in files for the data (text, text-properties, and possibly other information) in an Emacs buffer. Emacs performs format conversion if appropriate when reading and writing files. - Variable: format-alist This list contains one format definition for each defined file format. Each format definition is a list of this form: (NAME DOC-STRING REGEXP FROM-FN TO-FN MODIFY MODE-FN) Here is what the elements in a format definition mean: NAME The name of this format. DOC-STRING A documentation string for the format. REGEXP A regular expression which is used to recognize files represented in this format. FROM-FN A function to call to decode data in this format (to convert file data into the usual Emacs data representation). The FROM-FN is called with two args, BEGIN and END, which specify the part of the buffer it should convert. It should convert the text by editing it in place. Since this can change the length of the text, FROM-FN should return the modified end position. One responsibility of FROM-FN is to make sure that the beginning of the file no longer matches REGEXP. Otherwise it is likely to get called again. TO-FN A function to call to encode data in this format (to convert the usual Emacs data representation into this format). The TO-FN is called with two args, BEGIN and END, which specify the part of the buffer it should convert. There are two ways it can do the conversion: * By editing the buffer in place. In this case, TO-FN should return the end-position of the range of text, as modified. * By returning a list of annotations. This is a list of elements of the form `(POSITION . STRING)', where POSITION is an integer specifying the relative position in the text to be written, and STRING is the annotation to add there. The list must be sorted in order of position when TO-FN returns it. When `write-region' actually writes the text from the buffer to the file, it intermixes the specified annotations at the corresponding positions. All this takes place without modifying the buffer. MODIFY A flag, `t' if the encoding function modifies the buffer, and `nil' if it works by returning a list of annotations. MODE A mode function to call after visiting a file converted from this format. The function `insert-file-contents' automatically recognizes file formats when it reads the specified file. It checks the text of the beginning of the file against the regular expressions of the format definitions, and if it finds a match, it calls the decoding function for that format. Then it checks all the known formats over again. It keeps checking them until none of them is applicable. Visiting a file, with `find-file-noselect' or the commands that use it, performs conversion likewise (because it calls `insert-file-contents'); it also calls the mode function for each format that it decodes. It stores a list of the format names in the buffer-local variable `buffer-file-format'. - Variable: buffer-file-format This variable states the format of the visited file. More precisely, this is a list of the file format names that were decoded in the course of visiting the current buffer's file. It is always local in all buffers. When `write-region' writes data into a file, it first calls the encoding functions for the formats listed in `buffer-file-format', in the order of appearance in the list. - Function: format-write-file FILE FORMAT This command writes the current buffer contents into the file FILE in format FORMAT, and makes that format the default for future saves of the buffer. The argument FORMAT is a list of format names. - Function: format-find-file FILE FORMAT This command finds the file FILE, converting it according to format FORMAT. It also makes FORMAT the default if the buffer is saved later. The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just RET for FORMAT specifies `nil'. - Function: format-insert-file FILE FORMAT %OPTIONAL BEG END This command inserts the contents of file FILE, converting it according to format FORMAT. If BEG and END are non-`nil', they specify which part of the file to read, as in `insert-file-contents' (*note Reading from Files::.). The return value is like what `insert-file-contents' returns: a list of the absolute file name and the length of the data inserted (after conversion). The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just RET for FORMAT specifies `nil'. - Function: format-find-file FILE FORMAT This command finds the file FILE, converting it according to format FORMAT. It also makes FORMAT the default if the buffer is saved later. The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just RET for FORMAT specifies `nil'. - Function: format-insert-file FILE FORMAT %OPTIONAL BEG END This command inserts the contents of file FILE, converting it according to format FORMAT. If BEG and END are non-`nil', they specify which part of the file to read, as in `insert-file-contents' (*note Reading from Files::.). The return value is like what `insert-file-contents' returns: a list of the absolute file name and the length of the data inserted (after conversion). The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just RET for FORMAT specifies `nil'. - Variable: auto-save-file-format This variable specifies the format to use for auto-saving. Its value is a list of format names, just like the value of `buffer-file-format'; but it is used instead of `buffer-file-format' for writing auto-save files. This variable is always local in all buffers. File: lispref.info, Node: Files and MS-DOS, Prev: Format Conversion, Up: Files Files and MS-DOS ================ Emacs on MS-DOS makes a distinction between text files and binary files. This is necessary because ordinary text files on MS-DOS use a two character sequence between lines: carriage-return and linefeed (CRLF). Emacs expects just a newline character (a linefeed) between lines. When Emacs reads or writes a text file on MS-DOS, it needs to convert the line separators. This means it needs to know which files are text files and which are binary. It makes this decision when visiting a file, and records the decision in the variable `buffer-file-type' for use when the file is saved. *Note MS-DOS Subprocesses::, for a related feature for subprocesses. - Variable: buffer-file-type This variable, automatically local in each buffer, records the file type of the buffer's visited file. The value is `nil' for text, `t' for binary. - Function: find-buffer-file-type FILENAME This function determines whether file FILENAME is a text file or a binary file. It returns `nil' for text, `t' for binary. - User Option: file-name-buffer-file-type-alist This variable holds an alist for distinguishing text files from binary files. Each element has the form (REGEXP . TYPE), where REGEXP is matched against the file name, and TYPE may be is `nil' for text, `t' for binary, or a function to call to compute which. If it is a function, then it is called with a single argument (the file name) and should return `t' or `nil'. - User Option: default-buffer-file-type This variable specifies the default file type for files whose names don't indicate anything in particular. Its value should be `nil' for text, or `t' for binary. - Command: find-file-text FILENAME Like `find-file', but treat the file as text regardless of its name. - Command: find-file-binary FILENAME Like `find-file', but treat the file as binary regardless of its name. File: lispref.info, Node: Backups and Auto-Saving, Next: Buffers, Prev: Files, Up: Top Backups and Auto-Saving *********************** Backup files and auto-save files are two methods by which XEmacs tries to protect the user from the consequences of crashes or of the user's own errors. Auto-saving preserves the text from earlier in the current editing session; backup files preserve file contents prior to the current session. * Menu: * Backup Files:: How backup files are made; how their names are chosen. * Auto-Saving:: How auto-save files are made; how their names are chosen. * Reverting:: `revert-buffer', and how to customize what it does. File: lispref.info, Node: Backup Files, Next: Auto-Saving, Up: Backups and Auto-Saving Backup Files ============ A "backup file" is a copy of the old contents of a file you are editing. XEmacs makes a backup file the first time you save a buffer into its visited file. Normally, this means that the backup file contains the contents of the file as it was before the current editing session. The contents of the backup file normally remain unchanged once it exists. Backups are usually made by renaming the visited file to a new name. Optionally, you can specify that backup files should be made by copying the visited file. This choice makes a difference for files with multiple names; it also can affect whether the edited file remains owned by the original owner or becomes owned by the user editing it. By default, XEmacs makes a single backup file for each file edited. You can alternatively request numbered backups; then each new backup file gets a new name. You can delete old numbered backups when you don't want them any more, or XEmacs can delete them automatically. * Menu: * Making Backups:: How XEmacs makes backup files, and when. * Rename or Copy:: Two alternatives: renaming the old file or copying it. * Numbered Backups:: Keeping multiple backups for each source file. * Backup Names:: How backup file names are computed; customization. File: lispref.info, Node: Making Backups, Next: Rename or Copy, Up: Backup Files Making Backup Files ------------------- - Function: backup-buffer This function makes a backup of the file visited by the current buffer, if appropriate. It is called by `save-buffer' before saving the buffer the first time. - Variable: buffer-backed-up This buffer-local variable indicates whether this buffer's file has been backed up on account of this buffer. If it is non-`nil', then the backup file has been written. Otherwise, the file should be backed up when it is next saved (if backups are enabled). This is a permanent local; `kill-local-variables' does not alter it. - User Option: make-backup-files This variable determines whether or not to make backup files. If it is non-`nil', then XEmacs creates a backup of each file when it is saved for the first time--provided that `backup-inhibited' is `nil' (see below). The following example shows how to change the `make-backup-files' variable only in the `RMAIL' buffer and not elsewhere. Setting it `nil' stops XEmacs from making backups of the `RMAIL' file, which may save disk space. (You would put this code in your `.emacs' file.) (add-hook 'rmail-mode-hook (function (lambda () (make-local-variable 'make-backup-files) (setq make-backup-files nil)))) - Variable: backup-enable-predicate This variable's value is a function to be called on certain occasions to decide whether a file should have backup files. The function receives one argument, a file name to consider. If the function returns `nil', backups are disabled for that file. Otherwise, the other variables in this section say whether and how to make backups. The default value is this: (lambda (name) (or (< (length name) 5) (not (string-equal "/tmp/" (substring name 0 5))))) - Variable: backup-inhibited If this variable is non-`nil', backups are inhibited. It records the result of testing `backup-enable-predicate' on the visited file name. It can also coherently be used by other mechanisms that inhibit backups based on which file is visited. For example, VC sets this variable non-`nil' to prevent making backups for files managed with a version control system. This is a permanent local, so that changing the major mode does not lose its value. Major modes should not set this variable--they should set `make-backup-files' instead. File: lispref.info, Node: Rename or Copy, Next: Numbered Backups, Prev: Making Backups, Up: Backup Files Backup by Renaming or by Copying? --------------------------------- There are two ways that XEmacs can make a backup file: * XEmacs can rename the original file so that it becomes a backup file, and then write the buffer being saved into a new file. After this procedure, any other names (i.e., hard links) of the original file now refer to the backup file. The new file is owned by the user doing the editing, and its group is the default for new files written by the user in that directory. * XEmacs can copy the original file into a backup file, and then overwrite the original file with new contents. After this procedure, any other names (i.e., hard links) of the original file still refer to the current version of the file. The file's owner and group will be unchanged. The first method, renaming, is the default. The variable `backup-by-copying', if non-`nil', says to use the second method, which is to copy the original file and overwrite it with the new buffer contents. The variable `file-precious-flag', if non-`nil', also has this effect (as a sideline of its main significance). *Note Saving Buffers::. - Variable: backup-by-copying If this variable is non-`nil', XEmacs always makes backup files by copying. The following two variables, when non-`nil', cause the second method to be used in certain special cases. They have no effect on the treatment of files that don't fall into the special cases. - Variable: backup-by-copying-when-linked If this variable is non-`nil', XEmacs makes backups by copying for files with multiple names (hard links). This variable is significant only if `backup-by-copying' is `nil', since copying is always used when that variable is non-`nil'. - Variable: backup-by-copying-when-mismatch If this variable is non-`nil', XEmacs makes backups by copying in cases where renaming would change either the owner or the group of the file. The value has no effect when renaming would not alter the owner or group of the file; that is, for files which are owned by the user and whose group matches the default for a new file created there by the user. This variable is significant only if `backup-by-copying' is `nil', since copying is always used when that variable is non-`nil'. File: lispref.info, Node: Numbered Backups, Next: Backup Names, Prev: Rename or Copy, Up: Backup Files Making and Deleting Numbered Backup Files ----------------------------------------- If a file's name is `foo', the names of its numbered backup versions are `foo.~V~', for various integers V, like this: `foo.~1~', `foo.~2~', `foo.~3~', ..., `foo.~259~', and so on. - User Option: version-control This variable controls whether to make a single non-numbered backup file or multiple numbered backups. `nil' Make numbered backups if the visited file already has numbered backups; otherwise, do not. `never' Do not make numbered backups. ANYTHING ELSE Make numbered backups. The use of numbered backups ultimately leads to a large number of backup versions, which must then be deleted. XEmacs can do this automatically or it can ask the user whether to delete them. - User Option: kept-new-versions The value of this variable is the number of newest versions to keep when a new numbered backup is made. The newly made backup is included in the count. The default value is 2. - User Option: kept-old-versions The value of this variable is the number of oldest versions to keep when a new numbered backup is made. The default value is 2. If there are backups numbered 1, 2, 3, 5, and 7, and both of these variables have the value 2, then the backups numbered 1 and 2 are kept as old versions and those numbered 5 and 7 are kept as new versions; backup version 3 is excess. The function `find-backup-file-name' (*note Backup Names::.) is responsible for determining which backup versions to delete, but does not delete them itself. - User Option: trim-versions-without-asking If this variable is non-`nil', then saving a file deletes excess backup versions silently. Otherwise, it asks the user whether to delete them. - User Option: dired-kept-versions This variable specifies how many of the newest backup versions to keep in the Dired command `.' (`dired-clean-directory'). That's the same thing `kept-new-versions' specifies when you make a new backup file. The default value is 2. File: lispref.info, Node: Backup Names, Prev: Numbered Backups, Up: Backup Files Naming Backup Files ------------------- The functions in this section are documented mainly because you can customize the naming conventions for backup files by redefining them. If you change one, you probably need to change the rest. - Function: backup-file-name-p FILENAME This function returns a non-`nil' value if FILENAME is a possible name for a backup file. A file with the name FILENAME need not exist; the function just checks the name. (backup-file-name-p "foo") => nil (backup-file-name-p "foo~") => 3 The standard definition of this function is as follows: (defun backup-file-name-p (file) "Return non-nil if FILE is a backup file \ name (numeric or not)..." (string-match "~$" file)) Thus, the function returns a non-`nil' value if the file name ends with a `~'. (We use a backslash to split the documentation string's first line into two lines in the text, but produce just one line in the string itself.) This simple expression is placed in a separate function to make it easy to redefine for customization. - Function: make-backup-file-name FILENAME This function returns a string that is the name to use for a non-numbered backup file for file FILENAME. On Unix, this is just FILENAME with a tilde appended. The standard definition of this function is as follows: (defun make-backup-file-name (file) "Create the non-numeric backup file name for FILE. ..." (concat file "~")) You can change the backup-file naming convention by redefining this function. The following example redefines `make-backup-file-name' to prepend a `.' in addition to appending a tilde: (defun make-backup-file-name (filename) (concat "." filename "~")) (make-backup-file-name "backups.texi") => ".backups.texi~" - Function: find-backup-file-name FILENAME This function computes the file name for a new backup file for FILENAME. It may also propose certain existing backup files for deletion. `find-backup-file-name' returns a list whose CAR is the name for the new backup file and whose CDR is a list of backup files whose deletion is proposed. Two variables, `kept-old-versions' and `kept-new-versions', determine which backup versions should be kept. This function keeps those versions by excluding them from the CDR of the value. *Note Numbered Backups::. In this example, the value says that `~rms/foo.~5~' is the name to use for the new backup file, and `~rms/foo.~3~' is an "excess" version that the caller should consider deleting now. (find-backup-file-name "~rms/foo") => ("~rms/foo.~5~" "~rms/foo.~3~") - Function: file-newest-backup FILENAME This function returns the name of the most recent backup file for FILENAME, or `nil' if that file has no backup files. Some file comparison commands use this function so that they can automatically compare a file with its most recent backup. File: lispref.info, Node: Auto-Saving, Next: Reverting, Prev: Backup Files, Up: Backups and Auto-Saving Auto-Saving =========== XEmacs periodically saves all files that you are visiting; this is called "auto-saving". Auto-saving prevents you from losing more than a limited amount of work if the system crashes. By default, auto-saves happen every 300 keystrokes, or after around 30 seconds of idle time. *Note Auto-Save: (emacs)Auto-Save, for information on auto-save for users. Here we describe the functions used to implement auto-saving and the variables that control them. - Variable: buffer-auto-save-file-name This buffer-local variable is the name of the file used for auto-saving the current buffer. It is `nil' if the buffer should not be auto-saved. buffer-auto-save-file-name => "/xcssun/users/rms/lewis/#files.texi#" - Command: auto-save-mode ARG When used interactively without an argument, this command is a toggle switch: it turns on auto-saving of the current buffer if it is off, and vice-versa. With an argument ARG, the command turns auto-saving on if the value of ARG is `t', a nonempty list, or a positive integer. Otherwise, it turns auto-saving off. - Function: auto-save-file-name-p FILENAME This function returns a non-`nil' value if FILENAME is a string that could be the name of an auto-save file. It works based on knowledge of the naming convention for auto-save files: a name that begins and ends with hash marks (`#') is a possible auto-save file name. The argument FILENAME should not contain a directory part. (make-auto-save-file-name) => "/xcssun/users/rms/lewis/#files.texi#" (auto-save-file-name-p "#files.texi#") => 0 (auto-save-file-name-p "files.texi") => nil The standard definition of this function is as follows: (defun auto-save-file-name-p (filename) "Return non-nil if FILENAME can be yielded by..." (string-match "^#.*#$" filename)) This function exists so that you can customize it if you wish to change the naming convention for auto-save files. If you redefine it, be sure to redefine the function `make-auto-save-file-name' correspondingly. - Function: make-auto-save-file-name This function returns the file name to use for auto-saving the current buffer. This is just the file name with hash marks (`#') appended and prepended to it. This function does not look at the variable `auto-save-visited-file-name' (described below); you should check that before calling this function. (make-auto-save-file-name) => "/xcssun/users/rms/lewis/#backup.texi#" The standard definition of this function is as follows: (defun make-auto-save-file-name () "Return file name to use for auto-saves \ of current buffer. ..." (if buffer-file-name (concat (file-name-directory buffer-file-name) "#" (file-name-nondirectory buffer-file-name) "#") (expand-file-name (concat "#%" (buffer-name) "#")))) This exists as a separate function so that you can redefine it to customize the naming convention for auto-save files. Be sure to change `auto-save-file-name-p' in a corresponding way. - Variable: auto-save-visited-file-name If this variable is non-`nil', XEmacs auto-saves buffers in the files they are visiting. That is, the auto-save is done in the same file that you are editing. Normally, this variable is `nil', so auto-save files have distinct names that are created by `make-auto-save-file-name'. When you change the value of this variable, the value does not take effect until the next time auto-save mode is reenabled in any given buffer. If auto-save mode is already enabled, auto-saves continue to go in the same file name until `auto-save-mode' is called again. - Function: recent-auto-save-p This function returns `t' if the current buffer has been auto-saved since the last time it was read in or saved. - Function: set-buffer-auto-saved This function marks the current buffer as auto-saved. The buffer will not be auto-saved again until the buffer text is changed again. The function returns `nil'. - User Option: auto-save-interval The value of this variable is the number of characters that XEmacs reads from the keyboard between auto-saves. Each time this many more characters are read, auto-saving is done for all buffers in which it is enabled. - User Option: auto-save-timeout The value of this variable is the number of seconds of idle time that should cause auto-saving. Each time the user pauses for this long, XEmacs auto-saves any buffers that need it. (Actually, the specified timeout is multiplied by a factor depending on the size of the current buffer.) - Variable: auto-save-hook This normal hook is run whenever an auto-save is about to happen. - User Option: auto-save-default If this variable is non-`nil', buffers that are visiting files have auto-saving enabled by default. Otherwise, they do not. - Command: do-auto-save &optional NO-MESSAGE CURRENT-ONLY This function auto-saves all buffers that need to be auto-saved. It saves all buffers for which auto-saving is enabled and that have been changed since the previous auto-save. Normally, if any buffers are auto-saved, a message that says `Auto-saving...' is displayed in the echo area while auto-saving is going on. However, if NO-MESSAGE is non-`nil', the message is inhibited. If CURRENT-ONLY is non-`nil', only the current buffer is auto-saved. - Function: delete-auto-save-file-if-necessary This function deletes the current buffer's auto-save file if `delete-auto-save-files' is non-`nil'. It is called every time a buffer is saved. - Variable: delete-auto-save-files This variable is used by the function `delete-auto-save-file-if-necessary'. If it is non-`nil', Emacs deletes auto-save files when a true save is done (in the visited file). This saves disk space and unclutters your directory. - Function: rename-auto-save-file This function adjusts the current buffer's auto-save file name if the visited file name has changed. It also renames an existing auto-save file. If the visited file name has not changed, this function does nothing. - Variable: buffer-saved-size The value of this buffer-local variable is the length of the current buffer as of the last time it was read in, saved, or auto-saved. This is used to detect a substantial decrease in size, and turn off auto-saving in response. If it is -1, that means auto-saving is temporarily shut off in this buffer due to a substantial deletion. Explicitly saving the buffer stores a positive value in this variable, thus reenabling auto-saving. Turning auto-save mode off or on also alters this variable. - Variable: auto-save-list-file-name This variable (if non-`nil') specifies a file for recording the names of all the auto-save files. Each time XEmacs does auto-saving, it writes two lines into this file for each buffer that has auto-saving enabled. The first line gives the name of the visited file (it's empty if the buffer has none), and the second gives the name of the auto-save file. If XEmacs exits normally, it deletes this file. If XEmacs crashes, you can look in the file to find all the auto-save files that might contain work that was otherwise lost. The `recover-session' command uses these files. The default name for this file is in your home directory and starts with `.saves-'. It also contains the XEmacs process ID and the host name. File: lispref.info, Node: Reverting, Prev: Auto-Saving, Up: Backups and Auto-Saving Reverting ========= If you have made extensive changes to a file and then change your mind about them, you can get rid of them by reading in the previous version of the file with the `revert-buffer' command. *Note Reverting a Buffer: (emacs)Reverting. - Command: revert-buffer &optional CHECK-AUTO-SAVE NOCONFIRM This command replaces the buffer text with the text of the visited file on disk. This action undoes all changes since the file was visited or saved. If the argument CHECK-AUTO-SAVE is non-`nil', and the latest auto-save file is more recent than the visited file, `revert-buffer' asks the user whether to use that instead. Otherwise, it always uses the text of the visited file itself. Interactively, CHECK-AUTO-SAVE is set if there is a numeric prefix argument. Normally, `revert-buffer' asks for confirmation before it changes the buffer; but if the argument NOCONFIRM is non-`nil', `revert-buffer' does not ask for confirmation. Reverting tries to preserve marker positions in the buffer by using the replacement feature of `insert-file-contents'. If the buffer contents and the file contents are identical before the revert operation, reverting preserves all the markers. If they are not identical, reverting does change the buffer; then it preserves the markers in the unchanged text (if any) at the beginning and end of the buffer. Preserving any additional markers would be problematical. You can customize how `revert-buffer' does its work by setting these variables--typically, as buffer-local variables. - Variable: revert-buffer-function The value of this variable is the function to use to revert this buffer. If non-`nil', it is called as a function with no arguments to do the work of reverting. If the value is `nil', reverting works the usual way. Modes such as Dired mode, in which the text being edited does not consist of a file's contents but can be regenerated in some other fashion, give this variable a buffer-local value that is a function to regenerate the contents. - Variable: revert-buffer-insert-file-contents-function The value of this variable, if non-`nil', is the function to use to insert the updated contents when reverting this buffer. The function receives two arguments: first the file name to use; second, `t' if the user has asked to read the auto-save file. - Variable: before-revert-hook This normal hook is run by `revert-buffer' before actually inserting the modified contents--but only if `revert-buffer-function' is `nil'. Font Lock mode uses this hook to record that the buffer contents are no longer fontified. - Variable: after-revert-hook This normal hook is run by `revert-buffer' after actually inserting the modified contents--but only if `revert-buffer-function' is `nil'. Font Lock mode uses this hook to recompute the fonts for the updated buffer contents. File: lispref.info, Node: Buffers, Next: Windows, Prev: Backups and Auto-Saving, Up: Top Buffers ******* A "buffer" is a Lisp object containing text to be edited. Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files. While several buffers may exist at one time, exactly one buffer is designated the "current buffer" at any time. Most editing commands act on the contents of the current buffer. Each buffer, including the current buffer, may or may not be displayed in any windows. * Menu: * Buffer Basics:: What is a buffer? * Current Buffer:: Designating a buffer as current so primitives will access its contents. * Buffer Names:: Accessing and changing buffer names. * Buffer File Name:: The buffer file name indicates which file is visited. * Buffer Modification:: A buffer is "modified" if it needs to be saved. * Modification Time:: Determining whether the visited file was changed "behind XEmacs's back". * Read Only Buffers:: Modifying text is not allowed in a read-only buffer. * The Buffer List:: How to look at all the existing buffers. * Creating Buffers:: Functions that create buffers. * Killing Buffers:: Buffers exist until explicitly killed. * Indirect Buffers:: An indirect buffer shares text with some other buffer. File: lispref.info, Node: Buffer Basics, Next: Current Buffer, Up: Buffers Buffer Basics ============= A "buffer" is a Lisp object containing text to be edited. Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files. While several buffers may exist at one time, exactly one buffer is designated the "current buffer" at any time. Most editing commands act on the contents of the current buffer. Each buffer, including the current buffer, may or may not be displayed in any windows. Buffers in Emacs editing are objects that have distinct names and hold text that can be edited. Buffers appear to Lisp programs as a special data type. You can think of the contents of a buffer as an extendable string; insertions and deletions may occur in any part of the buffer. *Note Text::. A Lisp buffer object contains numerous pieces of information. Some of this information is directly accessible to the programmer through variables, while other information is accessible only through special-purpose functions. For example, the visited file name is directly accessible through a variable, while the value of point is accessible only through a primitive function. Buffer-specific information that is directly accessible is stored in "buffer-local" variable bindings, which are variable values that are effective only in a particular buffer. This feature allows each buffer to override the values of certain variables. Most major modes override variables such as `fill-column' or `comment-column' in this way. For more information about buffer-local variables and functions related to them, see *Note Buffer-Local Variables::. For functions and variables related to visiting files in buffers, see *Note Visiting Files:: and *Note Saving Buffers::. For functions and variables related to the display of buffers in windows, see *Note Buffers and Windows::. - Function: bufferp OBJECT This function returns `t' if OBJECT is a buffer, `nil' otherwise.